package com.atguigu.tingshu.album.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.atguigu.tingshu.album.mapper.*;
import com.atguigu.tingshu.album.service.BaseCategoryService;
import com.atguigu.tingshu.common.cache.TingshuCache;
import com.atguigu.tingshu.model.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@SuppressWarnings({"all"})
public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, BaseCategory1> implements BaseCategoryService {

    @Autowired
    private BaseCategory1Mapper baseCategory1Mapper;

    @Autowired
    private BaseCategory2Mapper baseCategory2Mapper;

    @Autowired
    private BaseCategory3Mapper baseCategory3Mapper;

    @Autowired
    private BaseCategoryViewMapper baseCategoryViewMapper;

    @Autowired
    private BaseAttributeMapper baseAttributeMapper;


    /**
     * 获取基础分类列表
     * <p>
     * 此方法从数据库中获取基础分类视图列表，并将其组织成一个嵌套的JSON对象列表
     * 每个分类级别都包含其子分类，形成一个树状结构
     *
     * @return List<JSONObject> 返回一个包含分类信息的JSON对象列表，如果列表为空则返回null
     */
    @Override
    public List<JSONObject> getBaseCategoryList() {
        // 初始化第一级分类列表
        List<JSONObject> categoryChild1List = new ArrayList<>();

        // 从数据库中获取所有基础分类视图
        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(null);
        // 将分类视图列表按第一级分类ID分组
        Map<Long, List<BaseCategoryView>> map1 = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
        // 遍历第一级分类
        Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator1 = map1.entrySet().iterator();

        while (iterator1.hasNext()) {
            // 获取当前第一级分类的ID和对应的视图列表
            Map.Entry<Long, List<BaseCategoryView>> entry1 = iterator1.next();
            Long category1Id = entry1.getKey();
            List<BaseCategoryView> categoryViewList1 = entry1.getValue();
            // 创建第一级分类的JSON对象
            JSONObject category1 = new JSONObject();
            category1.put("categoryId", category1Id);
            category1.put("categoryName", categoryViewList1.get(0).getCategory1Name());

            // 初始化第二级分类列表
            ArrayList<JSONObject> categoryChild2List = new ArrayList<>();
            // 遍历所有分类，用于构建第二级分类及其子分类
            // 构建第二级分类及其子分类
            Map<Long, List<BaseCategoryView>> map2 = categoryViewList1.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
            // 遍历第二级分类
            Iterator<Map.Entry<Long, List<BaseCategoryView>>> iterator2 = map2.entrySet().iterator();
            while (iterator2.hasNext()) {
                // 获取当前第二级分类的ID和对应的视图列表
                Map.Entry<Long, List<BaseCategoryView>> entry2 = iterator2.next();
                Long category2Id = entry2.getKey();
                List<BaseCategoryView> categoryViewList2 = entry2.getValue();
                // 创建第二级分类的JSON对象
                JSONObject category2 = new JSONObject();
                category2.put("categoryId", category2Id);
                category2.put("categoryName", categoryViewList2.get(0).getCategory2Name());

                // 构建第三级分类列表
                List<JSONObject> categoryChild3List = categoryViewList2.stream().map(baseCategoryView -> {
                    JSONObject category3 = new JSONObject();
                    Long category3Id = baseCategoryView.getCategory3Id();
                    String categoryName3 = baseCategoryView.getCategory3Name();
                    category3.put("categoryId", category3Id);
                    category3.put("categoryName", categoryName3);
                    return category3;
                }).collect(Collectors.toList());

                // 将第三级分类列表添加到第二级分类对象中
                category2.put("categoryChild", categoryChild3List);
                // 将第二级分类对象添加到第二级分类列表中
                categoryChild2List.add(category2);
            }
            // 将第二级分类列表添加到第一级分类对象中
            category1.put("categoryChild", categoryChild2List);

            // 将第一级分类对象添加到第一级分类列表中
            categoryChild1List.add(category1);
        }
        // 返回构建好的第一级分类列表，此处应返回categoryChild1List，而非null
        return categoryChild1List;
    }

    /**
     * 根据一级分类id查询属性列表
     *
     * @param category1Id
     * @return
     */
    @Override
    public List<BaseAttribute> findAttribute(Long category1Id) {
        // 调用mapper层方法
        return baseAttributeMapper.selectBaseAttribute(category1Id);
    }

    /**
     * 根据三级分类id查询分类信息
     *
     * @param category3Id
     * @return
     */
    @TingshuCache(prefix = "category:info:")
    @Override
    public BaseCategoryView getCategoryViewByCategory3Id(Long category3Id) {
        return baseCategoryViewMapper.selectById(category3Id);
    }

    /**
     * 根据一级分类id查询全部分类信息
     *
     * @param category1Id
     * @return
     */
    @Override
    public JSONObject getAllCategoryList(Long category1Id) {
        BaseCategory1 baseCategory1 = baseCategory1Mapper.selectById(category1Id);
        // 创建一级分类对象
        JSONObject category1 = new JSONObject();
        category1.put("categoryId", category1Id);
        category1.put("categoryName", baseCategory1.getName());
        // 获取全部分类信息
        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(
                new LambdaQueryWrapper<BaseCategoryView>().eq(BaseCategoryView::getCategory1Id, category1Id));
        // 根据二级分类id分组，转换数据
        Map<Long, List<BaseCategoryView>> category2Map = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
        List<JSONObject> category2ChildList = new ArrayList<>();
        for (Map.Entry<Long, List<BaseCategoryView>> entry2 : category2Map.entrySet()) {
            // 获取二级分类id
            Long category2Id = entry2.getKey();
            // 获取二级分类下的所有三级分类
            List<BaseCategoryView> category3List = entry2.getValue();
            // 创建二级分类对象
            JSONObject category2 = new JSONObject();
            category2.put("categoryId", category2Id);
            category2.put("categoryName", category3List.get(0).getCategory2Name());
            // 循环三级分类数据
            List<JSONObject> category3ChildList = new ArrayList<>();
            category3List.stream().forEach(category3View -> {
                JSONObject category3 = new JSONObject();
                category3.put("categoryId", category3View.getCategory3Id());
                category3.put("categoryName", category3View.getCategory3Name());
                category3ChildList.add(category3);
            });
            category2ChildList.add(category2);
            // 将三级分类列表添加到二级分类对象中
            category2.put("categoryChild", category3ChildList);
        }
        // 将二级分类列表添加到一级分类对象中
        category1.put("categoryChild", category2ChildList);
        return category1;
    }

    /**
     * 根据一级分类ID查找顶级的三级分类列表
     *
     * @param category1Id 一级分类的ID
     * @return 返回顶级的三级分类列表，限定最多7条记录
     */
    @Override
    public List<BaseCategory3> findTopBaseCategory3(Long category1Id) {
        // 查询属于指定一级分类的所有二级分类
        List<BaseCategory2> baseCategory2List = baseCategory2Mapper.selectList(new LambdaQueryWrapper<BaseCategory2>().eq(BaseCategory2::getCategory1Id, category1Id));
        // 提取二级分类的ID列表
        List<Long> category2IdList = baseCategory2List.stream().map(BaseCategory2::getId).collect(Collectors.toList());
        // 创建查询 wrapper，用于筛选顶级三级分类
        LambdaQueryWrapper<BaseCategory3> wrapper = new LambdaQueryWrapper<>();
        // 设置查询条件：三级分类为顶级分类，且属于二级分类ID列表中的任意一个，最后限制结果数量为7条
        wrapper.eq(BaseCategory3::getIsTop, 1).in(BaseCategory3::getCategory2Id, category2IdList).last(" limit 7 ");
        // 执行查询，获取顶级三级分类列表
        List<BaseCategory3> baseCategory3List = baseCategory3Mapper.selectList(wrapper);
        // 返回查询结果
        return baseCategory3List;
    }

}
